package com.ophiux.utils.common;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.QName;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;

import lombok.extern.slf4j.Slf4j;

/**
 * 说明：Object对象转map工具类 说明：<br>
 * <h1>创 建 人: hehailong</h1><br>
 * 创建日期: 2018年11月20日 下午5:02:13<br>
 * 修改记录：
 */
@Slf4j
public class MapUtil {
	public static void main(String[] args) {
		
	}
	/**
	 * 对象转为Map(值不为空)
	 * @param pojo
	 * @return
	 */
	public static HashMap<String, String> toMap(Object pojo) {
		HashMap<String, String> hashMap = new HashMap<String, String>();
		try {
			if (pojo == null)
				return hashMap;
			Method method[] = pojo.getClass().getDeclaredMethods();
			Field field[] = pojo.getClass().getDeclaredFields();
			
			List<Field> fieldList = new ArrayList<Field>();
			
			Class clz = pojo.getClass();
			while(clz != Object.class) {
				fieldList.addAll(Arrays.asList(clz.getDeclaredFields()));
				clz = clz.getSuperclass();
			}
			
			for (Field fd : fieldList) {
				String prpName = fd.getName();
				String getMetd = "get"
						+ fd.getName().substring(0, 1).toUpperCase()
						+ fd.getName().substring(1);
				Method tmethod = pojo.getClass().getMethod(getMetd);
				Object v =  tmethod.invoke(pojo);
				
			//	fd.setAccessible(true);
			//	Object v = fd.get(pojo);
				if (v != null) {
					hashMap.put(prpName, v+"");
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException();
		}

		return hashMap;
	}
	
	/**
	 * 对象转为TreeMap(值不为空)
	 * 首字母排序
	 * @param pojo
	 * @return
	 */
	public static SortedMap<String, String> toSortedMap(Object pojo) {
		SortedMap<String, String> treeMap = new TreeMap<String,String>();
		if (pojo == null)
			return treeMap;
		Method method[] = pojo.getClass().getDeclaredMethods();
		Field field[] = pojo.getClass().getDeclaredFields();
		for (Method md : method) {
			for (Field fd : field) {
				String prpName = fd.getName();
				String getMetd = "get"
						+ fd.getName().substring(0, 1).toUpperCase()
						+ fd.getName().substring(1);
				if (getMetd.equals(md.getName())) {
					try {
						Object v = md.invoke(pojo, new Object[0]);
						if (v != null) {
							treeMap.put(prpName, v+"");
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		}
		return treeMap;
		
		
	}
	
	public static Map<String, String> map2Bean(Object obj) {
        if (obj == null) {
            return null;
        }
        Map<String, String> map = new HashMap<String, String>();
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor property : propertyDescriptors) {
                String key = property.getName();
                // 过滤class属性
                if (!key.equals("class")) {
                    // 得到property对应的getter方法
                    Method getter = property.getReadMethod();
                    Object object = getter.invoke(obj);
                    if (object != null) {
                        String value = object.toString();
                        map.put(key, value);
                    }
                }
            }
        } catch (Exception e) {
            System.out.println("transBean2Map Error " + e);
        }
        return map;
    }
	
	/**
	 * Description:将json字符串转为SortedMap <br>
	 * 创 建 人: hhl
	 * 创建日期:2018年7月19日 上午9:38:37
	 * @param param
	 * @return
	 */
	public static SortedMap<String, String> JSONOToSortedMap(String param) {
		SortedMap<String, String> treeMap = new TreeMap<String,String>();
		treeMap = JSONObject.parseObject(param, new TypeReference<TreeMap<String, String>>(){});
		return treeMap;
	}
	
	/**
	 * 将XML的字符串转换为Map HIS返回的报文
	 * @param xmlStr  XML字符串
	 * @return	Map<String, Object>
	 */
	@SuppressWarnings("unchecked")
	public static Map<String, Object> parseXmlToMap(String xmlStr) {
		Document doc = null;
		Map<String, Object> map = null;
		try {
			doc = DocumentHelper.parseText(xmlStr);
			map = (Map<String, Object>) xml2map(doc.getRootElement());
		} catch (DocumentException e) {
			e.printStackTrace();
			log.info("BaseAdapterService=>parseXmlToMap(),异常:{}",e);
		}
		return map;
	}
	
	/**
	 * 说明: 将Object的字符串转换为Map<br/>
	 * 创建时间：2019年11月24日 上午10:45:53 <br/>
	 * @param obj	
	 * @return	Map<String, Object>
	 */
	public static Map<String, Object> parseXmlToMap(Object obj){
		Map<String, Object> temp = new HashMap<>(); 
		if(obj instanceof Map){
			temp = (Map<String, Object>)obj;
		}
		return temp;
	}
	
	/**
	 * 说明: 将Object的字符串转换为List<br/>
	 * 创建时间：2019年11月24日 上午10:46:36 <br/>
	 * @param obj
	 * @return	List<Map<String, Object>>
	 */
	public static List<Map<String, Object>> parseXmlToMapList(Object obj){
		//临时
		List<Map<String, Object>> temp_list = new ArrayList<Map<String,Object>>();
		//Map类型转换成List
		if(obj instanceof Map){
			temp_list.add((Map<String, Object>)obj);
		}
		//List强转
		if(obj instanceof List){
			temp_list = (List<Map<String, Object>>)obj;
		}
		return temp_list;
	}
	
	@SuppressWarnings("unchecked")
	public static Object xml2map(Element element) {
		Map<String, Object> map = new HashMap<String, Object>();
		List<Element> elements = element.elements();

		if (elements.size() == 0) { // 如果没有子节点
			map.put(element.getName(), element.getText());
			if (!element.isRootElement()) {
				return element.getText();
			}
		} else if (elements.size() == 1) { // 只有一个子节点
			map.put(elements.get(0).getName(), xml2map(elements.get(0)));
		} else if (elements.size() > 1) { // 含多个子节点

			Map<String, Element> tempMap = new HashMap<String, Element>();
			for (Element ele : elements) {
				tempMap.put(ele.getName(), ele);
			}
			Set<String> keySet = tempMap.keySet();
			for (String string : keySet) {
				Namespace namespace = tempMap.get(string).getNamespace();
				List<Element> elements2 = element.elements(new QName(string, namespace));
				// 如果同名的数目大于1则表示要构建list
				if (elements2.size() > 1) {
					List<Object> list = new ArrayList<Object>();
					for (Element ele : elements2) {
						list.add(xml2map(ele));
					}
					map.put(string, list);
				} else {
					// 同名的数量不大于1则直接递归去
					map.put(string, xml2map(elements2.get(0)));
				}
			}
		}
		return map;
	}
	
}
